import request from './request'
import { getFullImageUrl } from './imageHelper'

/**
 * API适配层 - 处理网关配置与前端请求的适配
 * 网关配置使用了StripPrefix=2过滤器，会去除/api/front前缀
 * 因此我们需要确保请求正确路由到后端服务
 */

/**
 * 处理前台图片URL，确保通过/image/{fileName}接口访问
 * @param {string} imagePath - 图片路径
 * @returns {string} - 处理后的图片URL
 */
export function getFrontImageUrl(imagePath) {
  return getFullImageUrl(imagePath, true)
}

/**
 * 处理带图片的活动数据对象，转换所有图片URL
 * @param {Object} eventData - 活动数据
 * @returns {Object} - 处理后的活动数据
 */
export function processEventImages(eventData) {
  if (!eventData) return eventData
  
  // 如果是数组，递归处理每个对象
  if (Array.isArray(eventData)) {
    return eventData.map(item => processEventImages(item))
  }
  
  // 如果是对象，深拷贝并处理cover字段
  const processedEvent = { ...eventData }
  
  // 处理cover字段
  if (processedEvent.cover) {
    processedEvent.cover = getFrontImageUrl(processedEvent.cover)
    
    // 如果没有coverUrl字段，则添加一个
    if (!processedEvent.coverUrl) {
      processedEvent.coverUrl = processedEvent.cover
    }
  }
  
  // 处理coverUrl字段（如果存在）
  if (processedEvent.coverUrl) {
    processedEvent.coverUrl = getFrontImageUrl(processedEvent.coverUrl)
  }
  
  // 处理eventCoverUrl字段（如果存在）
  if (processedEvent.eventCoverUrl) {
    processedEvent.eventCoverUrl = getFrontImageUrl(processedEvent.eventCoverUrl)
  }
  
  // 递归处理嵌套数据
  for (const key in processedEvent) {
    if (typeof processedEvent[key] === 'object' && processedEvent[key] !== null) {
      processedEvent[key] = processEventImages(processedEvent[key])
    }
  }
  
  return processedEvent
}

/**
 * 获取活动列表 - 提供多个备用路径
 */
export function getFrontEventList(params) {
  // 检查是否含有匿名访问标记
  const isAnonymous = params && params.anonymous === true
  
  // 尝试主路径 - '/api/front/events/list'
  return request({
    url: '/api/front/events/list',
    method: 'get',
    params,
    timeout: 10000,
    retry: false
  }).then(response => {
    // 处理返回数据中的图片URL
    if (response.code === 200 && response.data) {
      if (response.data.records) {
        response.data.records = processEventImages(response.data.records)
      } else if (Array.isArray(response.data)) {
        response.data = processEventImages(response.data)
      }
    }
    return response
  }).catch(error => {
    // 如果是404错误，尝试备用路径
    if (error.response && error.response.status === 404) {
      console.warn('主活动列表路径不存在，尝试备用路径1')
      // 备用路径1 - '/api/front/events'
      return request({
        url: '/api/front/events',
        method: 'get',
        params,
        timeout: 8000
      }).then(response => {
        // 处理返回数据中的图片URL
        if (response.code === 200 && response.data) {
          if (response.data.records) {
            response.data.records = processEventImages(response.data.records)
          } else if (Array.isArray(response.data)) {
            response.data = processEventImages(response.data)
          }
        }
        return response
      })
    }
    
    // 如果是401错误但请求中没有匿名标记，尝试以匿名方式重新请求
    if (!isAnonymous && error.response && error.response.status === 401) {
      console.log('检测到401错误，尝试匿名方式获取活动列表')
      return request({
        url: '/api/front/events/list',
        method: 'get',
        params: { ...params, anonymous: true, _t: Date.now() },
        timeout: 10000
      }).then(response => {
        // 处理返回数据中的图片URL
        if (response.code === 200 && response.data) {
          if (response.data.records) {
            response.data.records = processEventImages(response.data.records)
          } else if (Array.isArray(response.data)) {
            response.data = processEventImages(response.data)
          }
        }
        return response
      }).catch(anonymousError => {
        // 如果匿名请求失败且是404错误，尝试备用匿名路径
        if (anonymousError.response && anonymousError.response.status === 404) {
          console.warn('主活动列表匿名路径不存在，尝试备用匿名路径')
          return request({
            url: '/api/front/events',
            method: 'get',
            params: { ...params, anonymous: true, _t: Date.now() },
            timeout: 8000
          }).then(response => {
            // 处理返回数据中的图片URL
            if (response.code === 200 && response.data) {
              if (response.data.records) {
                response.data.records = processEventImages(response.data.records)
              } else if (Array.isArray(response.data)) {
                response.data = processEventImages(response.data)
              }
            }
            return response
          })
        }
        return Promise.reject(anonymousError)
      })
    }
    
    // 如果已经是重试请求，不再继续重试
    if (params.retry) {
      return Promise.reject(error)
    }
    
    console.warn('主活动列表请求失败，尝试备用路径:', error)
    
    // 尝试备用请求路径1 - 后备路径可能没有分页
    return request({
      url: '/api/front/events',
      method: 'get',
      params: { ...params, retry: true },
      timeout: 8000
    }).then(response => {
      // 处理返回数据中的图片URL
      if (response.code === 200 && response.data) {
        if (response.data.records) {
          response.data.records = processEventImages(response.data.records)
        } else if (Array.isArray(response.data)) {
          response.data = processEventImages(response.data)
        }
      }
      return response
    }).catch(backupError => {
      console.warn('备用活动列表路径1失败，尝试备用路径2:', backupError)
      
      // 尝试备用请求路径2 - 可能的标准REST路径
      return request({
        url: '/api/front/event',
        method: 'get',
        params: { ...params, retry: true },
        timeout: 8000
      }).then(response => {
        // 处理返回数据中的图片URL
        if (response.code === 200 && response.data) {
          if (response.data.records) {
            response.data.records = processEventImages(response.data.records)
          } else if (Array.isArray(response.data)) {
            response.data = processEventImages(response.data)
          }
        }
        return response
      }).catch(backupError2 => {
        console.warn('备用活动列表路径2失败，尝试备用路径3:', backupError2)
        
        // 尝试备用请求路径3 - 可能的简化REST路径
        return request({
          url: '/api/events',  // 尝试不带front前缀的路径
          method: 'get',
          params: { ...params, retry: true, frontend: true }, // 添加frontend标记区分
          timeout: 8000
        }).then(response => {
          // 处理返回数据中的图片URL
          if (response.code === 200 && response.data) {
            if (response.data.records) {
              response.data.records = processEventImages(response.data.records)
            } else if (Array.isArray(response.data)) {
              response.data = processEventImages(response.data)
            }
          }
          return response
        })
      })
    })
  })
}

/**
 * 获取活动详情
 */
export function getFrontEventDetail(id) {
  return request({
    url: `/api/front/events/detail/${id}`,
    method: 'get'
  }).then(response => {
    // 处理返回数据中的图片URL
    if (response.code === 200 && response.data) {
      response.data = processEventImages(response.data)
    }
    return response
  }).catch(error => {
    // 如果是401错误，尝试以匿名方式重新请求
    if (error.response && error.response.status === 401) {
      console.log('活动详情请求失败(401)，尝试匿名方式获取')
      return request({
        url: `/api/front/events/detail/${id}`,
        method: 'get',
        params: { anonymous: true, _t: Date.now() }
      }).then(response => {
        // 处理返回数据中的图片URL
        if (response.code === 200 && response.data) {
          response.data = processEventImages(response.data)
        }
        return response
      })
    }
    return Promise.reject(error)
  })
}

/**
 * 获取活动票种列表
 */
export function getFrontEventTickets(id) {
  return request({
    url: `/api/front/events/${id}/tickets`,
    method: 'get'
  }).then(response => {
    // 处理返回数据
    console.log('票种数据原始响应:', response)
    
    // 确保返回值格式正确
    if (response.code === 200 && response.data) {
      // 修复数据中可能存在的问题，确保关键字段存在
      if (Array.isArray(response.data)) {
        response.data = response.data.map(ticket => {
          // 创建新对象避免修改原始对象
          const processedTicket = { ...ticket };
          
          // 确保票种有status字段，默认为1（可用）
          if (processedTicket.status === undefined) {
            processedTicket.status = 1;
          }
          
          // 确保有remainingQuantity字段，如果没有则用totalStock-soldCount计算
          if (processedTicket.remainingQuantity === undefined) {
            const totalStock = processedTicket.totalStock || 0;
            const soldCount = processedTicket.soldCount || 0;
            processedTicket.remainingQuantity = totalStock - soldCount;
          }
          
          console.log('处理后的票种数据:', processedTicket);
          return processedTicket;
        });
      }
    }
    
    return response;
  }).catch(error => {
    // 如果是401错误，尝试以匿名方式重新请求
    if (error.response && error.response.status === 401) {
      console.log('票种列表请求失败(401)，尝试匿名方式获取')
      return request({
        url: `/api/front/events/${id}/tickets`,
        method: 'get',
        params: { anonymous: true, _t: Date.now() }
      }).then(response => {
        // 处理返回数据
        console.log('票种数据匿名响应:', response)
        
        // 确保返回值格式正确
        if (response.code === 200 && response.data) {
          // 修复数据中可能存在的问题，确保关键字段存在
          if (Array.isArray(response.data)) {
            response.data = response.data.map(ticket => {
              // 创建新对象避免修改原始对象
              const processedTicket = { ...ticket };
              
              // 确保票种有status字段，默认为1（可用）
              if (processedTicket.status === undefined) {
                processedTicket.status = 1;
              }
              
              // 确保有remainingQuantity字段，如果没有则用totalStock-soldCount计算
              if (processedTicket.remainingQuantity === undefined) {
                const totalStock = processedTicket.totalStock || 0;
                const soldCount = processedTicket.soldCount || 0;
                processedTicket.remainingQuantity = totalStock - soldCount;
              }
              
              return processedTicket;
            });
          }
        }
        
        return response;
      })
    }
    return Promise.reject(error)
  })
}

/**
 * 获取热门推荐活动
 */
export function getRecommendEvents(limit) {
  return request({
    url: '/api/front/events/recommend',
    method: 'get',
    params: { limit }
  }).then(response => {
    // 处理返回数据中的图片URL
    if (response.code === 200 && response.data) {
      response.data = processEventImages(response.data)
    }
    return response
  }).catch(error => {
    // 如果是401错误，尝试以匿名方式重新请求
    if (error.response && error.response.status === 401) {
      console.log('推荐活动请求失败(401)，尝试匿名方式获取')
      return request({
        url: '/api/front/events/recommend',
        method: 'get',
        params: { limit, anonymous: true, _t: Date.now() }
      }).then(response => {
        // 处理返回数据中的图片URL
        if (response.code === 200 && response.data) {
          response.data = processEventImages(response.data)
        }
        return response
      })
    }
    return Promise.reject(error)
  })
}

/**
 * 获取活动分类标签
 */
export function getEventCategories(params) {
  return request({
    url: '/api/front/events/categories',
    method: 'get',
    params
  }).catch(error => {
    // 如果是401错误，尝试以匿名方式重新请求
    if (error.response && error.response.status === 401) {
      console.log('分类标签请求失败(401)，尝试匿名方式获取')
      return request({
        url: '/api/front/events/categories',
        method: 'get',
        params: { ...(params || {}), anonymous: true, _t: Date.now() }
      })
    }
    return Promise.reject(error)
  })
}

/**
 * 参与前台活动
 */
export function joinFrontEvent(id) {
  return request({
    url: `/api/front/events/${id}/join`,
    method: 'post'
  })
}

/**
 * 取消参与前台活动
 */
export function cancelJoinFrontEvent(id) {
  return request({
    url: `/api/front/events/${id}/cancel`,
    method: 'post'
  })
} 